LC3 Info

Powerful List and Item objects interact with each other to serve as the focal point for the List Collection. LC3 includes the List and Item objects, 5 visible OCX display controls, 2 utility objects (Filer and Parse), and one OCX used for run-time property page access.

Starting with very flexible and highly-charged List and Item objects, LC3 already begins to fit into almost any solution. With more than 45 properties and methods, the Item object offers many ways to store and display your data. There's 3D Borders, Images, Fonts and colors, and rich-text display. For additional data, each Item also has extra string and numeric properties. There's even a property for storing other OLE objects!

Visual controls let you display your lists the way you want to: Item, Horz/Vert List, Tree, even specify each Item's size and location. Any List can be arranged hierarchically by specifying indent levels for Items. Many features include: customize default display of hierarchical and selected Items, design-time saving of Lists, push-button effects, simultaneous views of a List, sharing resources between Lists, load/save Lists to text and binary files, there's so much more!

All customers get free technical support and access to online software updates. LC3 ships with VBX's, 16&32 bit OLE Controls and Objects, sample images, and plenty of demos!

A simple but cool demo showing some formatting codes, word-wrapping, and settings for the ImagePos property. The ItemClick event uses the ItemPushed property to make a button-like push effect, and the ItemDblClick event uses the BorderPushed property to invert the border's bevelling.

Some Advanced features of the List Collection. When the cursor is passed over enabled Items in the lcGroup control (at top), the Item's Border is Raised providing a pop-up button effect. The lcGroup is also configured to display Items Horizontally as a Toolbar. Since the lcGroup also handles hierarchies, you could have levels of menus and options underneath each Item!

This demo shows how to use some of the advanced formatting codes available with the List Collection contols. Each Item in the List maintains the information for a single appointment. The ItemDblClick event is used to show an appointment properties dialog. When this information is changed, the display text is formatted using the FmtText property to display text with different colors, font attributes, and positioning. A database is also used to store all of the Appointments and associated properties.

The Filer Demo shows how to use the lcFiler object and the lcQuick to make a file and directory browser applet. A "memory-only" List is created and used to store the images displayed by the lcQuick control. On the ItemDblClick event, if the Item represents a directory, the subdirectories and files for that directory are logged and inserted into the List. When logging the subdirectories and files, the TextPath property is used to obtain a DOS-like path for the Item.

EventLog is a good way to learn the timing of events and the values of their parameters with the lcQuick OCX control. The Demo starts with some hierarchical information on the left and the EventLog on the right. Checkboxes are available to log only certain types of events.

This demo shows a whole directory of Images at a time. A directory of Bitmaps, Metafiles, and Icons is supplied with this demo to illustrate how you can use each type of Image in the same way. You are also allowed to adjust the ItemHeight, which will also show you how to use the ImageZoom property of the Item.

The VBParse demo brings together many of the List Collection objects to load, parse, and display VB code. The Symbols and Keywords used are stored in two text files and are loaded into the lcParseObj by using the LoadText method.

The List Collection is a set of components designed to handle the general programming problem of storing, manipulating, and displaying lists of data. The forte of the List Collection lies in its ability to handle large amounts of data quickly and provide highly-configurable mechanisms for displaying that data to the user of a program.
Specifically, the List Collection version 3 (LC3) has generic List and Item classes which provide a wide range of storage and display possibilities. These powerful List and Item objects interact with each other and also serve as the basis for the rest of the controls in the List Collection. LC3 currently includes (we are always adding to this product) 5 visible OCX controls used for display. These visible controls let you format and display your lists any way you want to: Item, List, Tree, Horizontal List, Vertical List, and even specify each Item's size and location. The List Collection also comes with two utility objects. One will fill a List with directory entries, and the other is a flexible parser.

During the redesign of the List Collection, we have taken a serious look at current technology and possible future innovations. Specifically, the latest version of the List Collection (LC3) has a heavy grounding in COM and OLE-related technologies. Consequently, you can perform operations with the List Collection that you wouldn't even have thought of before. Such as, having simultaneous multiple views of a single list, sharing resources between several different lists ( we already did this with the VBX's, but the OLE makes it an even more effective tool), type-safe programming by linking to the LC3 type libraries, and being able to maintain memory-only versions of list objects from many different devlopment platforms (VB, VBA, VBScript, etc.). Given this, we believe that the LC3 OCXs are the most powerful and flexible components on the market today!

Our world is ever-growing, and the demands that this places on our computer systems is ever-increasing. More RAM, more Hard Drive space, etc.,. Today's limitations eventually become tommorrow's standards. Many times, new versions of products are released simply to deal just with the increasing demands of technology. We can help you out here. The List Collection's main List object was designed to handle an extremely large number of Items (up to 2 billion and change, repeat: billion). In fact, it will continue to create new items for you until all of your computer's memory is exhausted! This means that you won't have to worry about whether the user wants to see 1,000 entries in your listbox or 1,000,000! As new standards evolve, the same List Collection components will handle the task. In other words, components that grow with you.

During the development of LC3, emphasis was placed on intelligent design and maximum performance. We are completely stunned by the results! Running on a Pentium90 with 16MB of RAM, the List Collection adds Items (w/ 20-character strings) at a rate of more than 15,000 per second! One of the major design decisions in this development effort was to encapsulate all of the List and Item functionality into seperate, shared objects. Therefore, all of the List Collection controls can use and share the same underlying List and Item objects between them, which shrinks the sizes of the OCXs dramatically (by about 75%). This allows the OCXs to load much faster as well as reduce the memory strain caused by duplicated control code.

You've probably tried some of the other List and Tree controls around. I have, and I find that some of them are pretty good. But in terms of capacity,speed, imaging, control over rich-text display, and UI customization, nothing compares to the List Collection! We started with a very powerful and highly-charged Item object, providing more than 45 properties and methods for storing and displaying your data. The List Collection Item object covers features like Item Borders, Hi-Res Images (w/ zoom!), individual fonts for Items, and rich-text display. The List object maintains a list of Items with the AddItem, Clear, RemoveItem, and RemoveTokens methods. Furthermore a List object can also copy Items between two Lists as well as load and save a List to disk.

The List Collection provides the Visual Programmer with a powerful set of list and tree controls to manipulate, query, and display user data. The List Collection is currently comprised of nine controls. There are seven displayable controls (CTree, EnhList, ImageBag, StyleBag, TabRas, TSTree, and TSLabel) and two hidden controls (MTree and LParse).

All of the List Collection Controls share the same set of standard list-interface properties (ListCount, ListIndex, NewIndex, List, ItemData). This allows the programmer to become familiar with the List Controls fairly easily, and provide a standard way to manipulate data from within each of the controls.

List Collection Controls also provides many features not found in other controls. Primarily, they all use a Virtual Memory subsystem which allow them to potentially access up to 500 Megabytes of RAM. This memory can be used to store lots data. In fact, each item in a list can store over 128K of data! The BatchMode property also helps to speed up intensive operations by postponing redundant calculations and paints until the end of the operation. This is great when you're adding a lot of items at once.

The Border properties allow you to display 3D Borders and Shadows. You can determine the dimensions of your border by using the BorderWidth, BevelOuter, BevelInner, and ShadowWidth properties. Customize the look of your border with the BevelLight, BevelDark, ShadowWidth and TrueShadow properties.

By using the ImageBag control, an almost unlimited number images (constrained only by available memory, of course) of varying dimensions and scales can be used to provide displayable images to other controls in the List Collection. This helps to conserve memory for often used images and also lets you create standardized images for use throughout your application. On the other hand, you can keep several ImageBags handy and change the appearance of your app on the fly.

Like the ImageBag, the StyleBag provides a convenient repository for often used item styles. Item styles can be used to greatly improve the look and feel of your program. Each item style not only lets you set all of the font and color attributes for an item, but also let you display Three-D borders and shadows around items. Again, you can mix and match StyleBags with other List Collection controls.

Many of the controls also support Control Flags. By using the ControlFlags property, you can control the display of the control's border, scrollbars, and focus rectangle. Certain special effects such as auto-expand/collapse, automatic scrolling, multiple selection, and item layout can also be set with this property.

Akin to Control Flags are Item Flags. These are flags which you can set for each item to define that item's image placement, text wrapping, text 3D and shadow effects, and highlighting. When connected to a StyleBag control, each item also has the ability to display borders, beveling, and shadows, also controlled by the ItemFlags( ) and StyleFlags( ) (for the StyleBag) properties.

The List Collection controls stand apart from many other types of listboxes by offering properties to display images, multi-colored text, and indention. Displayed text can be formatted by embedding formatting commands into the List( ) Property. Formatting commands are available to change font attributes, colors, and text placement. Since a format code can be placed anywhere in an item's text, you can display text with different font attributes and colors within a single item!

Some of the List Collection controls can be used to display data in an outline or hierarchical format. The CTree and TSTree controls let you set the indentation level of different items to establish parent-child relationships in your list that can be accessed by using the control's Tree properties. The MTree (an invisible memory-only control) and the TSTree both store hierarchical data in a somewhat different fashion. These controls provide you with special properties to navigate through lists of items, wherein each item in the list may have a sub-list of its own; a list of lists.

Each item in your list comes with a wide-range of properties which make them great, not only for data display but data storage as well. Each Item has a List (or ItemText) property to display formatted text in the display area of the control. Additional properties include ItemData and ItemString (also called ExtraString), used to store non-visible data associated with an item. An Item also has properties for item size, indentation, formatting, visibility, and disabling.

Another set of valuable properties found in these controls are the StartSearch, SearchString, FoundIndex, and SearchType properties. By using these properties, locating data within the control becomes an automated process and, consequently, more efficient than looping through and checking each item yourself.

In addition to many of the standard events available, there are several custom events that help you to write efficient and structured code. The IndexChange, ItemClick, ItemDblClick, and ItemOver events all provide you with information regarding the current selection, button presses, key presses, and mouse location.

The TSTree is a fully-featured, expandable and collapsible hierarchical listbox. By setting the indentation level of items, you can create parent-child relationships in your list. These hierarchical levels can be queried using properties such as ParentIndex, ChildCount, PrevSibIndex, etc.,. Each item in a TSTree provides the full complement of formatting and display possibilities. These include the embedded formatting commands, the ItemFlags, image display using an ImageBag control, and item style effects with a StyleBag. The control itself is fully configurable with 3D borders, shadows, and flags which control item selection, scrollbar display, and auto-expand/collapse. Items can also be individually set to be invisible, selected, or disabled.

The Tabula Rasa control also allows the full flexibility of control and item display as the TSTree does. Since TabRas stores data as lists of lists, each list is visible to the user at a given time. Using the auto-expand/collapse feature of this control, users can navigate through lists and sub-lists by clicking and double-clicking on items. This is a great tool for any drill-down type of operation. You can also select predefined layouts to arrange your items vertically or horizontally (a scrollable toolbar?), with or without item wrap-around. Tabula Rasa means "Blank Slate" in Latin, so, perhaps the best layout feature in this control is no layout at all! The TabRas control lets you remove any predefined layout, thereby allowing you to set the position, size, image, style, etc. of each item in your list. This control is too cool for words.

TSLabel is the odd one out. It's not a list, it's an item! This control mimics the properties of the items in List Collection listboxes. You have full control over font, color, images, styles, 3D text, shadowed text, etc.,. It can even be used as a button by employing special border flags to produce raised and pressed states. Don't forget, the TSLabel also displays up to 64K of formatted text (scrollbars are included).

The ImageBag provides a source for the images used in the above controls. The ImageBag connects to other controls much in the same way as binding to a data control works; set a property and you're ready to go. Images can be added to and removed from an ImageBag just like items in a listbox. Each image in the list has an ImageName, ImageWidth, ImageHeight, and ImageZoom property. Images can be loaded and saved to disk or copied to and from other controls that also have image properties. Linked controls can access a stored image by specifying either its index in the list or its name.

The StyleBag holds items which have specific style properties that allow configuration of item font, color, border, etc. By connecting to this control, other List Collection controls can have access to these styles and use them for customizing item display. By combining border and shadow properties, each item can act as button with raised and pressed states. Styles also let you easily indicate the state of list items such as parent items, child items, selected, and disabled items.

The CTree is a simplified version of the TSTree. It contains nine available "slots" for images that can be displayed with items in the list. Since it is a tree control, it also provides properties for indentation and hierarchical relationships. CTree also supports embedded formatting commands. This makes designing great looking interfaces a snap. We had to put something extra in this control, so, CTree can also serve as a read-only data browsing control. Each record is displayed on a separate line with fields being displayed according to formatting codes specific to each field.

This your basic listbox with some extra filing features. Since the EnhList doesn't display images or formatted text, it's simplicity makes it run much faster than the other visible controls in the Collection. It also has properties to display directory listings with all the associated file data such as file size and the date-time stamp. Furthermore, you can even read and write text files to and from the disk. The files contents will be displayed in the EnhList line by line. This is a great way to read and write INI files, log files, etc.

As an invisible version of the TabRas control, the MTree combines true hierarchical data storage without the overhead of a visible control. All of the same tree navigation properties apply to the MTree. You can store all of your data and then traverse it any way you want.

The LParse control is an invisible parsing control. This control is unique in that it exposes many of the components used in the parsing process by representing them as different lists. You can add and remove items in the keywords list to have LParse automatically search and identify keywords in the parse string. There's also a list for symbols, whitespace characters, and a list of tokens that result from the parsing operation. The results can be edited a token at a time and then used to generate a new string with the changes intact. The LParse can also automatically parse out numbers and quoted strings as single tokens.